home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DAsmSequence.cpp < prev    next >
Text File  |  1996-07-05  |  5KB  |  223 lines
  1. // DAsmSequence.cp 
  2. // d.g.gilbert
  3.  
  4.  
  5.  
  6. #include "DAsmSequence.h"
  7. #include "DSeqFile.h"
  8. #include "DSeqList.h"
  9. #include "DREnzyme.h"
  10. #include <ncbi.h>
  11. #include <dgg.h>
  12. #include <DUtil.h>
  13. #include <DFile.h>
  14. #include "ureadseq.h"
  15.  
  16.  
  17.  
  18.  
  19.  
  20.  
  21. // DAsmSequence -----------------
  22.  
  23.  
  24. DAsmSequence::DAsmSequence()
  25. {
  26.     fTrace= NULL;  
  27.     fTFName= NULL;
  28.   fNTrace= 0;
  29.   fMaxTrace= 0;
  30.   fTrCenter= NULL;
  31.   fTrlength= 0;
  32.     fShowTrace= TRUE;
  33.     fKind= kAutoseq;  
  34.     for (short t=0; t<4; t++) fMaxHeight[t]= 0;
  35. }
  36.  
  37. DAsmSequence::~DAsmSequence()  
  38. {
  39.     delete[] fTrace; //MemFree(fTrace);
  40.     MemFree(fTrCenter);
  41.     MemFree(fTFName);
  42. }
  43.  
  44. DObject* DAsmSequence::Clone() // override 
  45. {    
  46.     DAsmSequence* aSeq= (DAsmSequence*) DSequence::Clone();
  47.     aSeq->fTrace= NULL;  aSeq->SetTrace( fTrace, fNTrace, fMaxTrace, true);  
  48.     aSeq->fTrCenter= NULL; aSeq->SetTrCenter( fTrCenter, fTrlength, true); 
  49.     aSeq->fTFName= StrDup( fTFName);    
  50.     return aSeq;
  51. }
  52.  
  53. void DAsmSequence::CopyContents( DAsmSequence* fromSeq)
  54. {
  55.     DSequence::CopyContents( fromSeq);
  56.     fTFName= StrDup(fromSeq->fTFName);
  57.     SetTrace( fromSeq->fTrace, fromSeq->fNTrace, fromSeq->fMaxTrace, true);  
  58.     SetTrCenter( fromSeq->fTrCenter, fromSeq->fTrlength, true); 
  59. }
  60.  
  61. const char* DAsmSequence::TracefileName() 
  62. { 
  63.     return fTFName;
  64. }
  65.  
  66. void DAsmSequence::SetTracefileName(char* name) 
  67. { 
  68.     MemFree( fTFName);
  69.     fTFName= StrDup( name);
  70. }
  71.  
  72. TraceBase DAsmSequence::TraceAt(long item) 
  73. { 
  74.     TraceBase tr;
  75.     if (item >=0 && item <= fNTrace) return fTrace[item];
  76.     else return tr;
  77. }
  78.  
  79. void DAsmSequence::SetTraceAt(long item, TraceBase tr) 
  80. { 
  81.     if (item >=0 && item <= fNTrace) fTrace[item] = tr;
  82. }
  83.  
  84. void DAsmSequence::TraceToBases() 
  85. { 
  86.     if (fNTrace && fTrace) {
  87.         char *buf = (char*) MemNew( fNTrace+1);
  88.         long    i, len= 0;
  89.         for (i=0; i<fNTrace; i++)  
  90.             if (fTrace[i].base > ' ')  
  91.                 buf[len++]= fTrace[i].base;
  92.         buf[len]= 0;
  93.         buf= (char*) MemMore( buf, len+1); // size down
  94.         SetBases( buf, false);
  95.         }
  96. }
  97.  
  98. short DAsmSequence::MaxHeight(short trace) 
  99. { 
  100.     if (trace>=0 && trace<4) return fMaxHeight[trace];
  101.     else {
  102.         short maxt= 0;
  103.         for (short t=0; t<4; t++) if (fMaxHeight[t]>maxt) maxt= fMaxHeight[t];
  104.         return maxt;
  105.         }
  106. }
  107.  
  108. void  DAsmSequence::SetMaxHeight(short trace, short max) 
  109. { 
  110.     if (trace>=0 && trace<4) fMaxHeight[trace]= max; 
  111. }
  112.  
  113. void DAsmSequence::SetTrCenter( short*& theTrCenter, long trlength, Boolean duplicate)
  114. {
  115.     ulong bytesize= trlength * sizeof(short);
  116.     if (fTrCenter) { 
  117.         if (fTrlength>0 && 
  118.             (fTrlength != trlength || MemCmp( theTrCenter, fTrCenter, bytesize)!= 0))
  119.                 fChanged= TRUE;
  120.         MemFree(fTrCenter); 
  121.         fTrCenter= NULL; 
  122.         fTrlength= 0;
  123.         }
  124.     if (theTrCenter) {
  125.         if (duplicate) fTrCenter = (short*) MemDup(theTrCenter, bytesize); 
  126.         else { fTrCenter= theTrCenter; theTrCenter= NULL; }
  127.         fTrlength= trlength;  
  128.         }
  129.     fModTime= gUtil->time();
  130. }
  131.  
  132.  
  133. void DAsmSequence::UpdateTrace( TraceBase*& theTrace, long npoints, long maxtrace)
  134. {
  135.     ulong bytesize= npoints * sizeof(TraceBase);
  136.     
  137.     if (theTrace && theTrace != fTrace) {
  138.         SetTrace( theTrace, npoints, maxtrace, false);
  139.         theTrace= fTrace;
  140.         return;
  141.         }
  142.     
  143.     if (maxtrace > fMaxTrace) {
  144.         TraceBase* tmpb= new TraceBase[ maxtrace];
  145.         if (!tmpb) return;
  146.         if (fTrace && bytesize) {
  147.             MemCpy( tmpb, fTrace, bytesize);
  148.             delete[] fTrace;
  149.             }
  150.         fTrace= tmpb;
  151.         theTrace= fTrace;
  152.         fMaxTrace= maxtrace;
  153.         }
  154.     // ?? reduce fTrace if (maxtrace < fMaxTrace) ??
  155.  
  156.     fNTrace= Min( fMaxTrace, npoints);
  157.     fModTime= gUtil->time();
  158. }
  159.  
  160.  
  161. void DAsmSequence::SetTrace( TraceBase*& theTrace, long npoints, long maxtrace,
  162.                             Boolean duplicate)
  163. {
  164.     ulong bytesize= npoints * sizeof(TraceBase);
  165.     if (fTrace) { 
  166.         if (fNTrace>0 && 
  167.             (fNTrace != npoints || MemCmp( theTrace, fTrace, bytesize)!= 0))
  168.                 fChanged= TRUE;
  169.         delete[] fTrace;  //MemFree(e);  
  170.         fTrace= NULL; 
  171.         fNTrace= 0;
  172.         fMaxTrace= 0; 
  173.         }
  174.     if (theTrace) {
  175.         if (duplicate) {
  176.             fTrace = new TraceBase[ maxtrace];
  177.             MemCpy( fTrace, theTrace, bytesize);
  178.             }
  179.         else { fTrace= theTrace; theTrace= NULL; }
  180.         fNTrace= npoints;   
  181.         fMaxTrace= maxtrace; 
  182.         }
  183.     fModTime= gUtil->time();
  184. }
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191. void DAsmSequence::DoWrite(DFile* aFile, short format)
  192. {  
  193.     DSequence::DoWrite( aFile, format);
  194. #if 0    
  195.     if (fLength>0) {
  196.         DSeqFile::WriteSeqWrapper( aFile, fBases, fLength, format, fName);
  197.         if (fMasks && fMasksOk && DSeqFile::gWriteMasks) 
  198.             DSeqFile::WriteMaskWrapper( aFile, fMasks, fLength, format, fName);
  199.         }
  200. #endif
  201. }
  202.  
  203.  
  204. void DAsmSequence::DoWriteSelection(DFile* aFile, short format)
  205. {
  206.     DSequence::DoWriteSelection( aFile, format);
  207. #if 0    
  208.     if (fSelBases==0) 
  209.         DoWrite( aFile, format);
  210.     else if (fLength>0) {
  211.         long aStart= Min( fSelStart, fLength);
  212.         long aLength= Min( fSelBases, fLength - fSelStart);
  213.         DSeqFile::WriteSeqWrapper(  aFile, fBases+aStart, aLength, format, fName);
  214.         if (fMasks && fMasksOk && DSeqFile::gWriteMasks)  
  215.             DSeqFile::WriteMaskWrapper( aFile, fMasks+aStart, aLength, format, fName);
  216.         }
  217. #endif
  218. }
  219.  
  220.  
  221.  
  222.  
  223.